home *** CD-ROM | disk | FTP | other *** search
/ Languguage OS 2 / Languguage OS II Version 10-94 (Knowledge Media)(1994).ISO / gnu / libg_261.zip / libg_261 / libg++ / src / String.h < prev    next >
C/C++ Source or Header  |  1994-10-12  |  34KB  |  1,283 lines
  1. // This may look like C code, but it is really -*- C++ -*-
  2. /* 
  3. Copyright (C) 1988 Free Software Foundation
  4.     written by Doug Lea (dl@rocky.oswego.edu)
  5.  
  6. This file is part of the GNU C++ Library.  This library is free
  7. software; you can redistribute it and/or modify it under the terms of
  8. the GNU Library General Public License as published by the Free
  9. Software Foundation; either version 2 of the License, or (at your
  10. option) any later version.  This library is distributed in the hope
  11. that it will be useful, but WITHOUT ANY WARRANTY; without even the
  12. implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  13. PURPOSE.  See the GNU Library General Public License for more details.
  14. You should have received a copy of the GNU Library General Public
  15. License along with this library; if not, write to the Free Software
  16. Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  17. */
  18.  
  19.  
  20. #ifndef _String_h
  21. #ifdef __GNUG__
  22. #pragma interface
  23. #endif
  24. #define _String_h 1
  25.  
  26. #include <iostream.h>
  27. #include <Regex.h>
  28.  
  29. struct StrRep                     // internal String representations
  30. {
  31.   unsigned short    len;         // string length 
  32.   unsigned short    sz;          // allocated space
  33.   char              s[1];        // the string starts here 
  34.                                  // (at least 1 char for trailing null)
  35.                                  // allocated & expanded via non-public fcts
  36. };
  37.  
  38. // primitive ops on StrReps -- nearly all String fns go through these.
  39.  
  40. StrRep*     Salloc(StrRep*, const char*, int, int);
  41. StrRep*     Scopy(StrRep*, const StrRep*);
  42. StrRep*     Scat(StrRep*, const char*, int, const char*, int);
  43. StrRep*     Scat(StrRep*, const char*, int,const char*,int, const char*,int);
  44. StrRep*     Sprepend(StrRep*, const char*, int);
  45. StrRep*     Sreverse(const StrRep*, StrRep*);
  46. StrRep*     Supcase(const StrRep*, StrRep*);
  47. StrRep*     Sdowncase(const StrRep*, StrRep*);
  48. StrRep*     Scapitalize(const StrRep*, StrRep*);
  49.  
  50. // These classes need to be defined in the order given
  51.  
  52. class String;
  53. class SubString;
  54.  
  55. class SubString
  56. {
  57.   friend class      String;
  58. protected:
  59.  
  60.   String&           S;        // The String I'm a substring of
  61.   unsigned short    pos;      // starting position in S's rep
  62.   unsigned short    len;      // length of substring
  63.  
  64.   void              assign(const StrRep*, const char*, int = -1);
  65.                     SubString(String& x, int p, int l);
  66.                     SubString(const SubString& x);
  67.  
  68. public:
  69.  
  70. // Note there are no public constructors. SubStrings are always
  71. // created via String operations
  72.  
  73.                    ~SubString();
  74.  
  75.   SubString&        operator =  (const String&     y);
  76.   SubString&        operator =  (const SubString&  y);
  77.   SubString&        operator =  (const char* t);
  78.   SubString&        operator =  (char        c);
  79.  
  80. // return 1 if target appears anywhere in SubString; else 0
  81.  
  82.   int               contains(char        c) const;
  83.   int               contains(const String&     y) const;
  84.   int               contains(const SubString&  y) const;
  85.   int               contains(const char* t) const;
  86.   int               contains(const Regex&       r) const;
  87.  
  88. // return 1 if target matches entire SubString
  89.  
  90.   int               matches(const Regex&  r) const;
  91.  
  92. // IO 
  93.  
  94.   friend ostream&   operator<<(ostream& s, const SubString& x);
  95.  
  96. // status
  97.  
  98.   unsigned int      length() const;
  99.   int               empty() const;
  100.   const char*       chars() const;
  101.  
  102.   int               OK() const; 
  103.  
  104. };
  105.  
  106.  
  107. class String
  108. {
  109.   friend class      SubString;
  110.  
  111. protected:
  112.   StrRep*           rep;   // Strings are pointers to their representations
  113.  
  114. // some helper functions
  115.  
  116.   int               search(int, int, const char*, int = -1) const;
  117.   int               search(int, int, char) const;
  118.   int               match(int, int, int, const char*, int = -1) const;
  119.   int               _gsub(const char*, int, const char* ,int);
  120.   int               _gsub(const Regex&, const char*, int);
  121.   SubString         _substr(int, int);
  122.  
  123. public:
  124.  
  125. // constructors & assignment
  126.  
  127.                     String();
  128.                     String(const String& x);
  129.                     String(const SubString&  x);
  130.                     String(const char* t);
  131.                     String(const char* t, int len);
  132.                     String(char c);
  133.  
  134.                     ~String();
  135.  
  136.   String&           operator =  (const String&     y);
  137.   String&           operator =  (const char* y);
  138.   String&           operator =  (char        c);
  139.   String&           operator =  (const SubString&  y);
  140.  
  141. // concatenation
  142.  
  143.   String&           operator += (const String&     y); 
  144.   String&           operator += (const SubString&  y);
  145.   String&           operator += (const char* t);
  146.   String&           operator += (char        c);
  147.  
  148.   void              prepend(const String&     y); 
  149.   void              prepend(const SubString&  y);
  150.   void              prepend(const char* t);
  151.   void              prepend(char        c);
  152.  
  153.  
  154. // procedural versions:
  155. // concatenate first 2 args, store result in last arg
  156.  
  157.   friend inline void     cat(const String&, const String&, String&);
  158.   friend inline void     cat(const String&, const SubString&, String&);
  159.   friend inline void     cat(const String&, const char*, String&);
  160.   friend inline void     cat(const String&, char, String&);
  161.  
  162.   friend inline void     cat(const SubString&, const String&, String&);
  163.   friend inline void     cat(const SubString&, const SubString&, String&);
  164.   friend inline void     cat(const SubString&, const char*, String&);
  165.   friend inline void     cat(const SubString&, char, String&);
  166.  
  167.   friend inline void     cat(const char*, const String&, String&);
  168.   friend inline void     cat(const char*, const SubString&, String&);
  169.   friend inline void     cat(const char*, const char*, String&);
  170.   friend inline void     cat(const char*, char, String&);
  171.  
  172. // double concatenation, by request. (yes, there are too many versions, 
  173. // but if one is supported, then the others should be too...)
  174. // Concatenate first 3 args, store in last arg
  175.  
  176.   friend inline void     cat(const String&,const String&, const String&,String&);
  177.   friend inline void     cat(const String&,const String&,const SubString&,String&);
  178.   friend inline void     cat(const String&,const String&, const char*, String&);
  179.   friend inline void     cat(const String&,const String&, char, String&);
  180.   friend inline void     cat(const String&,const SubString&,const String&,String&);
  181.   inline friend void     cat(const String&,const SubString&,const SubString&,String&);
  182.   friend inline void     cat(const String&,const SubString&, const char*, String&);
  183.   friend inline void     cat(const String&,const SubString&, char, String&);
  184.   friend inline void     cat(const String&,const char*, const String&,    String&);
  185.   friend inline void     cat(const String&,const char*, const SubString&, String&);
  186.   friend inline void     cat(const String&,const char*, const char*, String&);
  187.   friend inline void     cat(const String&,const char*, char, String&);
  188.  
  189.   friend inline void     cat(const char*, const String&, const String&,String&);
  190.   friend inline void     cat(const char*,const String&,const SubString&,String&);
  191.   friend inline void     cat(const char*,const String&, const char*, String&);
  192.   friend inline void     cat(const char*,const String&, char, String&);
  193.   friend inline void     cat(const char*,const SubString&,const String&,String&);
  194.   friend inline void     cat(const char*,const SubString&,const SubString&,String&);
  195.   friend inline void     cat(const char*,const SubString&, const char*, String&);
  196.   friend inline void     cat(const char*,const SubString&, char, String&);
  197.   friend inline void     cat(const char*,const char*, const String&,    String&);
  198.   friend inline void     cat(const char*,const char*, const SubString&, String&);
  199.   friend inline void     cat(const char*,const char*, const char*, String&);
  200.   friend inline void     cat(const char*,const char*, char, String&);
  201.  
  202.  
  203. // searching & matching
  204.  
  205. // return position of target in string or -1 for failure
  206.  
  207.   int               index(char        c, int startpos = 0) const;      
  208.   int               index(const String&     y, int startpos = 0) const;      
  209.   int               index(const SubString&  y, int startpos = 0) const;      
  210.   int               index(const char* t, int startpos = 0) const;  
  211.   int               index(const Regex&      r, int startpos = 0) const;       
  212.  
  213. // return 1 if target appears anyhere in String; else 0
  214.  
  215.   int               contains(char        c) const;
  216.   int               contains(const String&     y) const;
  217.   int               contains(const SubString&  y) const;
  218.   int               contains(const char* t) const;
  219.   int               contains(const Regex&      r) const;
  220.  
  221. // return 1 if target appears anywhere after position pos 
  222. // (or before, if pos is negative) in String; else 0
  223.  
  224.   int               contains(char        c, int pos) const;
  225.   int               contains(const String&     y, int pos) const;
  226.   int               contains(const SubString&  y, int pos) const;
  227.   int               contains(const char* t, int pos) const;
  228.   int               contains(const Regex&      r, int pos) const;
  229.  
  230. // return 1 if target appears at position pos in String; else 0
  231.  
  232.   int               matches(char        c, int pos = 0) const;
  233.   int               matches(const String&     y, int pos = 0) const;
  234.   int               matches(const SubString&  y, int pos = 0) const;
  235.   int               matches(const char* t, int pos = 0) const;
  236.   int               matches(const Regex&      r, int pos = 0) const;
  237.  
  238. //  return number of occurences of target in String
  239.  
  240.   int               freq(char        c) const; 
  241.   int               freq(const String&     y) const;
  242.   int               freq(const SubString&  y) const;
  243.   int               freq(const char* t) const;
  244.  
  245. // SubString extraction
  246.  
  247. // Note that you can't take a substring of a const String, since
  248. // this leaves open the possiblility of indirectly modifying the
  249. // String through the SubString
  250.  
  251.   SubString         at(int         pos, int len);
  252.   SubString         operator () (int         pos, int len); // synonym for at
  253.  
  254.   SubString         at(const String&     x, int startpos = 0); 
  255.   SubString         at(const SubString&  x, int startpos = 0); 
  256.   SubString         at(const char* t, int startpos = 0);
  257.   SubString         at(char        c, int startpos = 0);
  258.   SubString         at(const Regex&      r, int startpos = 0); 
  259.  
  260.   SubString         before(int          pos);
  261.   SubString         before(const String&      x, int startpos = 0);
  262.   SubString         before(const SubString&   x, int startpos = 0);
  263.   SubString         before(const char*  t, int startpos = 0);
  264.   SubString         before(char         c, int startpos = 0);
  265.   SubString         before(const Regex&       r, int startpos = 0);
  266.  
  267.   SubString         through(int          pos);
  268.   SubString         through(const String&      x, int startpos = 0);
  269.   SubString         through(const SubString&   x, int startpos = 0);
  270.   SubString         through(const char*  t, int startpos = 0);
  271.   SubString         through(char         c, int startpos = 0);
  272.   SubString         through(const Regex&       r, int startpos = 0);
  273.  
  274.   SubString         from(int          pos);
  275.   SubString         from(const String&      x, int startpos = 0);
  276.   SubString         from(const SubString&   x, int startpos = 0);
  277.   SubString         from(const char*  t, int startpos = 0);
  278.   SubString         from(char         c, int startpos = 0);
  279.   SubString         from(const Regex&       r, int startpos = 0);
  280.  
  281.   SubString         after(int         pos);
  282.   SubString         after(const String&     x, int startpos = 0);
  283.   SubString         after(const SubString&  x, int startpos = 0);
  284.   SubString         after(const char* t, int startpos = 0);
  285.   SubString         after(char        c, int startpos = 0);
  286.   SubString         after(const Regex&      r, int startpos = 0);
  287.  
  288.  
  289. // deletion
  290.  
  291. // delete len chars starting at pos
  292.   void              del(int         pos, int len);
  293.  
  294. // delete the first occurrence of target after startpos
  295.  
  296.   void              del(const String&     y, int startpos = 0);
  297.   void              del(const SubString&  y, int startpos = 0);
  298.   void              del(const char* t, int startpos = 0);
  299.   void              del(char        c, int startpos = 0);
  300.   void              del(const Regex&      r, int startpos = 0);
  301.  
  302. // global substitution: substitute all occurrences of pat with repl
  303.  
  304.   int               gsub(const String&     pat, const String&     repl);
  305.   int               gsub(const SubString&  pat, const String&     repl);
  306.   int               gsub(const char* pat, const String&     repl);
  307.   int               gsub(const char* pat, const char* repl);
  308.   int               gsub(const Regex&      pat, const String&     repl);
  309.  
  310. // friends & utilities
  311.  
  312. // split string into array res at separators; return number of elements
  313.  
  314.   friend int        split(const String& x, String res[], int maxn, 
  315.                           const String& sep);
  316.   friend int        split(const String& x, String res[], int maxn, 
  317.                           const Regex&  sep);
  318.  
  319.   friend String     common_prefix(const String& x, const String& y, 
  320.                                   int startpos = 0);
  321.   friend String     common_suffix(const String& x, const String& y, 
  322.                                   int startpos = -1);
  323.   friend String     replicate(char        c, int n);
  324.   friend String     replicate(const String&     y, int n);
  325.   friend String     join(String src[], int n, const String& sep);
  326.  
  327. // simple builtin transformations
  328.  
  329.   friend inline String     reverse(const String& x);
  330.   friend inline String     upcase(const String& x);
  331.   friend inline String     downcase(const String& x);
  332.   friend inline String     capitalize(const String& x);
  333.  
  334. // in-place versions of above
  335.  
  336.   void              reverse();
  337.   void              upcase();
  338.   void              downcase();
  339.   void              capitalize();
  340.  
  341. // element extraction
  342.  
  343.   char&             operator [] (int i);
  344.   const char&       operator [] (int i) const;
  345.   char              elem(int i) const;
  346.   char              firstchar() const;
  347.   char              lastchar() const;
  348.  
  349. // conversion
  350.  
  351.                     operator const char*() const;
  352.   const char*       chars() const;
  353.  
  354.  
  355. // IO
  356.  
  357.   friend inline ostream&   operator<<(ostream& s, const String& x);
  358.   friend ostream&   operator<<(ostream& s, const SubString& x);
  359.   friend istream&   operator>>(istream& s, String& x);
  360.  
  361.   friend int        readline(istream& s, String& x, 
  362.                              char terminator = '\n',
  363.                              int discard_terminator = 1);
  364.  
  365. // status
  366.  
  367.   unsigned int      length() const;
  368.   int               empty() const;
  369.  
  370. // preallocate some space for String
  371.   void              alloc(int newsize);
  372.  
  373. // report current allocation (not length!)
  374.  
  375.   int               allocation() const;
  376.  
  377.  
  378.   void     error(const char* msg) const;
  379.  
  380.   int               OK() const;
  381. };
  382.  
  383. typedef String StrTmp; // for backward compatibility
  384.  
  385. // other externs
  386.  
  387. int        compare(const String&    x, const String&     y);
  388. int        compare(const String&    x, const SubString&  y);
  389. int        compare(const String&    x, const char* y);
  390. int        compare(const SubString& x, const String&     y);
  391. int        compare(const SubString& x, const SubString&  y);
  392. int        compare(const SubString& x, const char* y);
  393. int        fcompare(const String&   x, const String&     y); // ignore case
  394.  
  395. extern StrRep  _nilStrRep;
  396. extern String _nilString;
  397.  
  398. // status reports, needed before defining other things
  399.  
  400. inline unsigned int String::length() const {  return rep->len; }
  401. inline int         String::empty() const { return rep->len == 0; }
  402. inline const char* String::chars() const { return &(rep->s[0]); }
  403. inline int         String::allocation() const { return rep->sz; }
  404.  
  405. inline unsigned int SubString::length() const { return len; }
  406. inline int         SubString::empty() const { return len == 0; }
  407. inline const char* SubString::chars() const { return &(S.rep->s[pos]); }
  408.  
  409.  
  410. // constructors
  411.  
  412. inline String::String() 
  413.   : rep(&_nilStrRep) {}
  414. inline String::String(const String& x) 
  415.   : rep(Scopy(0, x.rep)) {}
  416. inline String::String(const char* t) 
  417.   : rep(Salloc(0, t, -1, -1)) {}
  418. inline String::String(const char* t, int tlen)
  419.   : rep(Salloc(0, t, tlen, tlen)) {}
  420. inline String::String(const SubString& y)
  421.   : rep(Salloc(0, y.chars(), y.length(), y.length())) {}
  422. inline String::String(char c) 
  423.   : rep(Salloc(0, &c, 1, 1)) {}
  424.  
  425. inline String::~String() { if (rep != &_nilStrRep) delete rep; }
  426.  
  427. inline SubString::SubString(const SubString& x)
  428.   :S(x.S), pos(x.pos), len(x.len) {}
  429. inline SubString::SubString(String& x, int first, int l)
  430.   :S(x), pos(first), len(l) {}
  431.  
  432. inline SubString::~SubString() {}
  433.  
  434. // assignment
  435.  
  436. inline String& String::operator =  (const String& y)
  437. { 
  438.   rep = Scopy(rep, y.rep);
  439.   return *this;
  440. }
  441.  
  442. inline String& String::operator=(const char* t)
  443. {
  444.   rep = Salloc(rep, t, -1, -1);
  445.   return *this;
  446. }
  447.  
  448. inline String& String::operator=(const SubString&  y)
  449. {
  450.   rep = Salloc(rep, y.chars(), y.length(), y.length());
  451.   return *this;
  452. }
  453.  
  454. inline String& String::operator=(char c)
  455. {
  456.   rep = Salloc(rep, &c, 1, 1);
  457.   return *this;
  458. }
  459.  
  460.  
  461. inline SubString& SubString::operator = (const char* ys)
  462. {
  463.   assign(0, ys);
  464.   return *this;
  465. }
  466.  
  467. inline SubString& SubString::operator = (char ch)
  468. {
  469.   assign(0, &ch, 1);
  470.   return *this;
  471. }
  472.  
  473. inline SubString& SubString::operator = (const String& y)
  474. {
  475.   assign(y.rep, y.chars(), y.length());
  476.   return *this;
  477. }
  478.  
  479. inline SubString& SubString::operator = (const SubString& y)
  480. {
  481.   assign(y.S.rep, y.chars(), y.length());
  482.   return *this;
  483. }
  484.  
  485. // Zillions of cats...
  486.  
  487. inline void cat(const String& x, const String& y, String& r)
  488. {
  489.   r.rep = Scat(r.rep, x.chars(), x.length(), y.chars(), y.length());
  490. }
  491.  
  492. inline void cat(const String& x, const SubString& y, String& r)
  493. {
  494.   r.rep = Scat(r.rep, x.chars(), x.length(), y.chars(), y.length());
  495. }
  496.  
  497. inline void cat(const String& x, const char* y, String& r)
  498. {
  499.   r.rep = Scat(r.rep, x.chars(), x.length(), y, -1);
  500. }
  501.  
  502. inline void cat(const String& x, char y, String& r)
  503. {
  504.   r.rep = Scat(r.rep, x.chars(), x.length(), &y, 1);
  505. }
  506.  
  507. inline void cat(const SubString& x, const String& y, String& r)
  508. {
  509.   r.rep = Scat(r.rep, x.chars(), x.length(), y.chars(), y.length());
  510. }
  511.  
  512. inline void cat(const SubString& x, const SubString& y, String& r)
  513. {
  514.   r.rep = Scat(r.rep, x.chars(), x.length(), y.chars(), y.length());
  515. }
  516.  
  517. inline void cat(const SubString& x, const char* y, String& r)
  518. {
  519.   r.rep = Scat(r.rep, x.chars(), x.length(), y, -1);
  520. }
  521.  
  522. inline void cat(const SubString& x, char y, String& r)
  523. {
  524.   r.rep = Scat(r.rep, x.chars(), x.length(), &y, 1);
  525. }
  526.  
  527. inline void cat(const char* x, const String& y, String& r)
  528. {
  529.   r.rep = Scat(r.rep, x, -1, y.chars(), y.length());
  530. }
  531.  
  532. inline void cat(const char* x, const SubString& y, String& r)
  533. {
  534.   r.rep = Scat(r.rep, x, -1, y.chars(), y.length());
  535. }
  536.  
  537. inline void cat(const char* x, const char* y, String& r)
  538. {
  539.   r.rep = Scat(r.rep, x, -1, y, -1);
  540. }
  541.  
  542. inline void cat(const char* x, char y, String& r)
  543. {
  544.   r.rep = Scat(r.rep, x, -1, &y, 1);
  545. }
  546.  
  547. inline void cat(const String& a, const String& x, const String& y, String& r)
  548. {
  549.   r.rep = Scat(r.rep, a.chars(), a.length(), x.chars(), x.length(), y.chars(), y.length());
  550. }
  551.  
  552. inline void cat(const String& a, const String& x, const SubString& y, String& r)
  553. {
  554.   r.rep = Scat(r.rep, a.chars(), a.length(), x.chars(), x.length(), y.chars(), y.length());
  555. }
  556.  
  557. inline void cat(const String& a, const String& x, const char* y, String& r)
  558. {
  559.   r.rep = Scat(r.rep, a.chars(), a.length(), x.chars(), x.length(), y, -1);
  560. }
  561.  
  562. inline void cat(const String& a, const String& x, char y, String& r)
  563. {
  564.   r.rep = Scat(r.rep, a.chars(), a.length(), x.chars(), x.length(), &y, 1);
  565. }
  566.  
  567. inline void cat(const String& a, const SubString& x, const String& y, String& r)
  568. {
  569.   r.rep = Scat(r.rep, a.chars(), a.length(), x.chars(), x.length(), y.chars(), y.length());
  570. }
  571.  
  572. inline void cat(const String& a, const SubString& x, const SubString& y, String& r)
  573. {
  574.   r.rep = Scat(r.rep, a.chars(), a.length(), x.chars(), x.length(), y.chars(), y.length());
  575. }
  576.  
  577. inline void cat(const String& a, const SubString& x, const char* y, String& r)
  578. {
  579.   r.rep = Scat(r.rep, a.chars(), a.length(), x.chars(), x.length(), y, -1);
  580. }
  581.  
  582. inline void cat(const String& a, const SubString& x, char y, String& r)
  583. {
  584.   r.rep = Scat(r.rep, a.chars(), a.length(), x.chars(), x.length(), &y, 1);
  585. }
  586.  
  587. inline void cat(const String& a, const char* x, const String& y, String& r)
  588. {
  589.   r.rep = Scat(r.rep, a.chars(), a.length(), x, -1, y.chars(), y.length());
  590. }
  591.  
  592. inline void cat(const String& a, const char* x, const SubString& y, String& r)
  593. {
  594.   r.rep = Scat(r.rep, a.chars(), a.length(), x, -1, y.chars(), y.length());
  595. }
  596.  
  597. inline void cat(const String& a, const char* x, const char* y, String& r)
  598. {
  599.   r.rep = Scat(r.rep, a.chars(), a.length(), x, -1, y, -1);
  600. }
  601.  
  602. inline void cat(const String& a, const char* x, char y, String& r)
  603. {
  604.   r.rep = Scat(r.rep, a.chars(), a.length(), x, -1, &y, 1);
  605. }
  606.  
  607.  
  608. inline void cat(const char* a, const String& x, const String& y, String& r)
  609. {
  610.   r.rep = Scat(r.rep, a, -1, x.chars(), x.length(), y.chars(), y.length());
  611. }
  612.  
  613. inline void cat(const char* a, const String& x, const SubString& y, String& r)
  614. {
  615.   r.rep = Scat(r.rep, a, -1, x.chars(), x.length(), y.chars(), y.length());
  616. }
  617.  
  618. inline void cat(const char* a, const String& x, const char* y, String& r)
  619. {
  620.   r.rep = Scat(r.rep, a, -1, x.chars(), x.length(), y, -1);
  621. }
  622.  
  623. inline void cat(const char* a, const String& x, char y, String& r)
  624. {
  625.   r.rep = Scat(r.rep, a, -1, x.chars(), x.length(), &y, 1);
  626. }
  627.  
  628. inline void cat(const char* a, const SubString& x, const String& y, String& r)
  629. {
  630.   r.rep = Scat(r.rep, a, -1, x.chars(), x.length(), y.chars(), y.length());
  631. }
  632.  
  633. inline void cat(const char* a, const SubString& x, const SubString& y, String& r)
  634. {
  635.   r.rep = Scat(r.rep, a, -1, x.chars(), x.length(), y.chars(), y.length());
  636. }
  637.  
  638. inline void cat(const char* a, const SubString& x, const char* y, String& r)
  639. {
  640.   r.rep = Scat(r.rep, a, -1, x.chars(), x.length(), y, -1);
  641. }
  642.  
  643. inline void cat(const char* a, const SubString& x, char y, String& r)
  644. {
  645.   r.rep = Scat(r.rep, a, -1, x.chars(), x.length(), &y, 1);
  646. }
  647.  
  648. inline void cat(const char* a, const char* x, const String& y, String& r)
  649. {
  650.   r.rep = Scat(r.rep, a, -1, x, -1, y.chars(), y.length());
  651. }
  652.  
  653. inline void cat(const char* a, const char* x, const SubString& y, String& r)
  654. {
  655.   r.rep = Scat(r.rep, a, -1, x, -1, y.chars(), y.length());
  656. }
  657.  
  658. inline void cat(const char* a, const char* x, const char* y, String& r)
  659. {
  660.   r.rep = Scat(r.rep, a, -1, x, -1, y, -1);
  661. }
  662.  
  663. inline void cat(const char* a, const char* x, char y, String& r)
  664. {
  665.   r.rep = Scat(r.rep, a, -1, x, -1, &y, 1);
  666. }
  667.  
  668.  
  669. // operator versions
  670.  
  671. inline String& String::operator +=(const String& y)
  672. {
  673.   cat(*this, y, *this);
  674.   return *this;
  675. }
  676.  
  677. inline String& String::operator +=(const SubString& y)
  678. {
  679.   cat(*this, y, *this);
  680.   return *this;
  681. }
  682.  
  683. inline String& String::operator += (const char* y)
  684. {
  685.   cat(*this, y, *this);
  686.   return *this;
  687. }
  688.  
  689. inline String& String:: operator +=(char y)
  690. {
  691.   cat(*this, y, *this);
  692.   return *this;
  693. }
  694.  
  695. // constructive concatenation
  696.  
  697. #if defined(__GNUG__) && !defined(_G_NO_NRV)
  698.  
  699. inline String operator + (const String& x, const String& y) return r;
  700. {
  701.   cat(x, y, r);
  702. }
  703.  
  704. inline String operator + (const String& x, const SubString& y) return r;
  705. {
  706.   cat(x, y, r);
  707. }
  708.  
  709. inline String operator + (const String& x, const char* y) return r;
  710. {
  711.   cat(x, y, r);
  712. }
  713.  
  714. inline String operator + (const String& x, char y) return r;
  715. {
  716.   cat(x, y, r);
  717. }
  718.  
  719. inline String operator + (const SubString& x, const String& y) return r;
  720. {
  721.   cat(x, y, r);
  722. }
  723.  
  724. inline String operator + (const SubString& x, const SubString& y) return r;
  725. {
  726.   cat(x, y, r);
  727. }
  728.  
  729. inline String operator + (const SubString& x, const char* y) return r;
  730. {
  731.   cat(x, y, r);
  732. }
  733.  
  734. inline String operator + (const SubString& x, char y) return r;
  735. {
  736.   cat(x, y, r);
  737. }
  738.  
  739. inline String operator + (const char* x, const String& y) return r;
  740. {
  741.   cat(x, y, r);
  742. }
  743.  
  744. inline String operator + (const char* x, const SubString& y) return r;
  745. {
  746.   cat(x, y, r);
  747. }
  748.  
  749. inline String reverse(const String& x) return r;
  750. {
  751.   r.rep = Sreverse(x.rep, r.rep);
  752. }
  753.  
  754. inline String upcase(const String& x) return r;
  755. {
  756.   r.rep = Supcase(x.rep, r.rep);
  757. }
  758.  
  759. inline String downcase(const String& x) return r;
  760. {
  761.   r.rep = Sdowncase(x.rep, r.rep);
  762. }
  763.  
  764. inline String capitalize(const String& x) return r;
  765. {
  766.   r.rep = Scapitalize(x.rep, r.rep);
  767. }
  768.  
  769. #else /* NO_NRV */
  770.  
  771. inline String operator + (const String& x, const String& y)
  772. {
  773.   String r;  cat(x, y, r);  return r;
  774. }
  775.  
  776. inline String operator + (const String& x, const SubString& y) 
  777. {
  778.   String r; cat(x, y, r); return r;
  779. }
  780.  
  781. inline String operator + (const String& x, const char* y) 
  782. {
  783.   String r; cat(x, y, r); return r;
  784. }
  785.  
  786. inline String operator + (const String& x, char y) 
  787. {
  788.   String r; cat(x, y, r); return r;
  789. }
  790.  
  791. inline String operator + (const SubString& x, const String& y) 
  792. {
  793.   String r; cat(x, y, r); return r;
  794. }
  795.  
  796. inline String operator + (const SubString& x, const SubString& y) 
  797. {
  798.   String r; cat(x, y, r); return r;
  799. }
  800.  
  801. inline String operator + (const SubString& x, const char* y) 
  802. {
  803.   String r; cat(x, y, r); return r;
  804. }
  805.  
  806. inline String operator + (const SubString& x, char y) 
  807. {
  808.   String r; cat(x, y, r); return r;
  809. }
  810.  
  811. inline String operator + (const char* x, const String& y) 
  812. {
  813.   String r; cat(x, y, r); return r;
  814. }
  815.  
  816. inline String operator + (const char* x, const SubString& y) 
  817. {
  818.   String r; cat(x, y, r); return r;
  819. }
  820.  
  821. inline String reverse(const String& x) 
  822. {
  823.   String r; r.rep = Sreverse(x.rep, r.rep); return r;
  824. }
  825.  
  826. inline String upcase(const String& x) 
  827. {
  828.   String r; r.rep = Supcase(x.rep, r.rep); return r;
  829. }
  830.  
  831. inline String downcase(const String& x) 
  832. {
  833.   String r; r.rep = Sdowncase(x.rep, r.rep); return r;
  834. }
  835.  
  836. inline String capitalize(const String& x) 
  837. {
  838.   String r; r.rep = Scapitalize(x.rep, r.rep); return r;
  839. }
  840.  
  841. #endif
  842.  
  843. // prepend
  844.  
  845. inline void String::prepend(const String& y)
  846. {
  847.   rep = Sprepend(rep, y.chars(), y.length());
  848. }
  849.  
  850. inline void String::prepend(const char* y)
  851. {
  852.   rep = Sprepend(rep, y, -1); 
  853. }
  854.  
  855. inline void String::prepend(char y)
  856. {
  857.   rep = Sprepend(rep, &y, 1); 
  858. }
  859.  
  860. inline void String::prepend(const SubString& y)
  861. {
  862.   rep = Sprepend(rep, y.chars(), y.length());
  863. }
  864.  
  865. // misc transformations
  866.  
  867.  
  868. inline void String::reverse()
  869. {
  870.   rep = Sreverse(rep, rep);
  871. }
  872.  
  873.  
  874. inline void String::upcase()
  875. {
  876.   rep = Supcase(rep, rep);
  877. }
  878.  
  879.  
  880. inline void String::downcase()
  881. {
  882.   rep = Sdowncase(rep, rep);
  883. }
  884.  
  885.  
  886. inline void String::capitalize()
  887. {
  888.   rep = Scapitalize(rep, rep);
  889. }
  890.  
  891. // element extraction
  892.  
  893. inline char&  String::operator [] (int i) 
  894. { 
  895.   if (((unsigned)i) >= length()) error("invalid index");
  896.   return rep->s[i];
  897. }
  898.  
  899. inline const char&  String::operator [] (int i) const
  900. { 
  901.   if (((unsigned)i) >= length()) error("invalid index");
  902.   return rep->s[i];
  903. }
  904.  
  905. inline char  String::elem (int i) const
  906. { 
  907.   if (((unsigned)i) >= length()) error("invalid index");
  908.   return rep->s[i];
  909. }
  910.  
  911. inline char  String::firstchar() const
  912. { 
  913.   return elem(0);
  914. }
  915.  
  916. inline char  String::lastchar() const
  917. { 
  918.   return elem(length() - 1);
  919. }
  920.  
  921. // searching
  922.  
  923. inline int String::index(char c, int startpos) const
  924. {
  925.   return search(startpos, length(), c);
  926. }
  927.  
  928. inline int String::index(const char* t, int startpos) const
  929. {   
  930.   return search(startpos, length(), t);
  931. }
  932.  
  933. inline int String::index(const String& y, int startpos) const
  934. {   
  935.   return search(startpos, length(), y.chars(), y.length());
  936. }
  937.  
  938. inline int String::index(const SubString& y, int startpos) const
  939. {   
  940.   return search(startpos, length(), y.chars(), y.length());
  941. }
  942.  
  943. inline int String::index(const Regex& r, int startpos) const
  944. {
  945.   int unused;  return r.search(chars(), length(), unused, startpos);
  946. }
  947.  
  948. inline int String::contains(char c) const
  949. {
  950.   return search(0, length(), c) >= 0;
  951. }
  952.  
  953. inline int String::contains(const char* t) const
  954. {   
  955.   return search(0, length(), t) >= 0;
  956. }
  957.  
  958. inline int String::contains(const String& y) const
  959. {   
  960.   return search(0, length(), y.chars(), y.length()) >= 0;
  961. }
  962.  
  963. inline int String::contains(const SubString& y) const
  964. {   
  965.   return search(0, length(), y.chars(), y.length()) >= 0;
  966. }
  967.  
  968. inline int String::contains(char c, int p) const
  969. {
  970.   return match(p, length(), 0, &c, 1) >= 0;
  971. }
  972.  
  973. inline int String::contains(const char* t, int p) const
  974. {
  975.   return match(p, length(), 0, t) >= 0;
  976. }
  977.  
  978. inline int String::contains(const String& y, int p) const
  979. {
  980.   return match(p, length(), 0, y.chars(), y.length()) >= 0;
  981. }
  982.  
  983. inline int String::contains(const SubString& y, int p) const
  984. {
  985.   return match(p, length(), 0, y.chars(), y.length()) >= 0;
  986. }
  987.  
  988. inline int String::contains(const Regex& r) const
  989. {
  990.   int unused;  return r.search(chars(), length(), unused, 0) >= 0;
  991. }
  992.  
  993. inline int String::contains(const Regex& r, int p) const
  994. {
  995.   return r.match(chars(), length(), p) >= 0;
  996. }
  997.  
  998.  
  999. inline int String::matches(const SubString& y, int p) const
  1000. {
  1001.   return match(p, length(), 1, y.chars(), y.length()) >= 0;
  1002. }
  1003.  
  1004. inline int String::matches(const String& y, int p) const
  1005. {
  1006.   return match(p, length(), 1, y.chars(), y.length()) >= 0;
  1007. }
  1008.  
  1009. inline int String::matches(const char* t, int p) const
  1010. {
  1011.   return match(p, length(), 1, t) >= 0;
  1012. }
  1013.  
  1014. inline int String::matches(char c, int p) const
  1015. {
  1016.   return match(p, length(), 1, &c, 1) >= 0;
  1017. }
  1018.  
  1019. inline int String::matches(const Regex& r, int p) const
  1020. {
  1021.   int l = (p < 0)? -p : length() - p;
  1022.   return r.match(chars(), length(), p) == l;
  1023. }
  1024.  
  1025.  
  1026. inline int SubString::contains(const char* t) const
  1027. {   
  1028.   return S.search(pos, pos+len, t) >= 0;
  1029. }
  1030.  
  1031. inline int SubString::contains(const String& y) const
  1032. {   
  1033.   return S.search(pos, pos+len, y.chars(), y.length()) >= 0;
  1034. }
  1035.  
  1036. inline int SubString::contains(const SubString&  y) const
  1037. {   
  1038.   return S.search(pos, pos+len, y.chars(), y.length()) >= 0;
  1039. }
  1040.  
  1041. inline int SubString::contains(char c) const
  1042. {
  1043.   return S.search(pos, pos+len, c) >= 0;
  1044. }
  1045.  
  1046. inline int SubString::contains(const Regex& r) const
  1047. {
  1048.   int unused;  return r.search(chars(), len, unused, 0) >= 0;
  1049. }
  1050.  
  1051. inline int SubString::matches(const Regex& r) const
  1052. {
  1053.   return r.match(chars(), len, 0) == len;
  1054. }
  1055.  
  1056.  
  1057. inline int String::gsub(const String& pat, const String& r)
  1058. {
  1059.   return _gsub(pat.chars(), pat.length(), r.chars(), r.length());
  1060. }
  1061.  
  1062. inline int String::gsub(const SubString&  pat, const String& r)
  1063. {
  1064.   return _gsub(pat.chars(), pat.length(), r.chars(), r.length());
  1065. }
  1066.  
  1067. inline int String::gsub(const Regex& pat, const String& r)
  1068. {
  1069.   return _gsub(pat, r.chars(), r.length());
  1070. }
  1071.  
  1072. inline int String::gsub(const char* pat, const String& r)
  1073. {
  1074.   return _gsub(pat, -1, r.chars(), r.length());
  1075. }
  1076.  
  1077. inline int String::gsub(const char* pat, const char* r)
  1078. {
  1079.   return _gsub(pat, -1, r, -1);
  1080. }
  1081.  
  1082.  
  1083.  
  1084. inline  ostream& operator<<(ostream& s, const String& x)
  1085. {
  1086.    s << x.chars(); return s;
  1087. }
  1088.  
  1089. // a zillion comparison operators
  1090.  
  1091. inline int operator==(const String& x, const String& y) 
  1092. {
  1093.   return compare(x, y) == 0; 
  1094. }
  1095.  
  1096. inline int operator!=(const String& x, const String& y)
  1097. {
  1098.   return compare(x, y) != 0; 
  1099. }
  1100.  
  1101. inline int operator>(const String& x, const String& y)
  1102. {
  1103.   return compare(x, y) > 0; 
  1104. }
  1105.  
  1106. inline int operator>=(const String& x, const String& y)
  1107. {
  1108.   return compare(x, y) >= 0; 
  1109. }
  1110.  
  1111. inline int operator<(const String& x, const String& y)
  1112. {
  1113.   return compare(x, y) < 0; 
  1114. }
  1115.  
  1116. inline int operator<=(const String& x, const String& y)
  1117. {
  1118.   return compare(x, y) <= 0; 
  1119. }
  1120.  
  1121. inline int operator==(const String& x, const SubString&  y) 
  1122. {
  1123.   return compare(x, y) == 0; 
  1124. }
  1125.  
  1126. inline int operator!=(const String& x, const SubString&  y)
  1127. {
  1128.   return compare(x, y) != 0; 
  1129. }
  1130.  
  1131. inline int operator>(const String& x, const SubString&  y)      
  1132. {
  1133.   return compare(x, y) > 0; 
  1134. }
  1135.  
  1136. inline int operator>=(const String& x, const SubString&  y)
  1137. {
  1138.   return compare(x, y) >= 0; 
  1139. }
  1140.  
  1141. inline int operator<(const String& x, const SubString&  y) 
  1142. {
  1143.   return compare(x, y) < 0; 
  1144. }
  1145.  
  1146. inline int operator<=(const String& x, const SubString&  y)
  1147. {
  1148.   return compare(x, y) <= 0; 
  1149. }
  1150.  
  1151. inline int operator==(const String& x, const char* t) 
  1152. {
  1153.   return compare(x, t) == 0; 
  1154. }
  1155.  
  1156. inline int operator!=(const String& x, const char* t) 
  1157. {
  1158.   return compare(x, t) != 0; 
  1159. }
  1160.  
  1161. inline int operator>(const String& x, const char* t)  
  1162. {
  1163.   return compare(x, t) > 0; 
  1164. }
  1165.  
  1166. inline int operator>=(const String& x, const char* t) 
  1167. {
  1168.   return compare(x, t) >= 0; 
  1169. }
  1170.  
  1171. inline int operator<(const String& x, const char* t)  
  1172. {
  1173.   return compare(x, t) < 0; 
  1174. }
  1175.  
  1176. inline int operator<=(const String& x, const char* t) 
  1177. {
  1178.   return compare(x, t) <= 0; 
  1179. }
  1180.  
  1181. inline int operator==(const SubString& x, const String& y) 
  1182. {
  1183.   return compare(y, x) == 0; 
  1184. }
  1185.  
  1186. inline int operator!=(const SubString& x, const String& y)
  1187. {
  1188.   return compare(y, x) != 0;
  1189. }
  1190.  
  1191. inline int operator>(const SubString& x, const String& y)      
  1192. {
  1193.   return compare(y, x) < 0;
  1194. }
  1195.  
  1196. inline int operator>=(const SubString& x, const String& y)     
  1197. {
  1198.   return compare(y, x) <= 0;
  1199. }
  1200.  
  1201. inline int operator<(const SubString& x, const String& y)      
  1202. {
  1203.   return compare(y, x) > 0;
  1204. }
  1205.  
  1206. inline int operator<=(const SubString& x, const String& y)     
  1207. {
  1208.   return compare(y, x) >= 0;
  1209. }
  1210.  
  1211. inline int operator==(const SubString& x, const SubString&  y) 
  1212. {
  1213.   return compare(x, y) == 0; 
  1214. }
  1215.  
  1216. inline int operator!=(const SubString& x, const SubString&  y)
  1217. {
  1218.   return compare(x, y) != 0;
  1219. }
  1220.  
  1221. inline int operator>(const SubString& x, const SubString&  y)      
  1222. {
  1223.   return compare(x, y) > 0;
  1224. }
  1225.  
  1226. inline int operator>=(const SubString& x, const SubString&  y)
  1227. {
  1228.   return compare(x, y) >= 0;
  1229. }
  1230.  
  1231. inline int operator<(const SubString& x, const SubString&  y) 
  1232. {
  1233.   return compare(x, y) < 0;
  1234. }
  1235.  
  1236. inline int operator<=(const SubString& x, const SubString&  y)
  1237. {
  1238.   return compare(x, y) <= 0;
  1239. }
  1240.  
  1241. inline int operator==(const SubString& x, const char* t) 
  1242. {
  1243.   return compare(x, t) == 0; 
  1244. }
  1245.  
  1246. inline int operator!=(const SubString& x, const char* t) 
  1247. {
  1248.   return compare(x, t) != 0;
  1249. }
  1250.  
  1251. inline int operator>(const SubString& x, const char* t)  
  1252. {
  1253.   return compare(x, t) > 0; 
  1254. }
  1255.  
  1256. inline int operator>=(const SubString& x, const char* t) 
  1257. {
  1258.   return compare(x, t) >= 0; 
  1259. }
  1260.  
  1261. inline int operator<(const SubString& x, const char* t)  
  1262. {
  1263.   return compare(x, t) < 0; 
  1264. }
  1265.  
  1266. inline int operator<=(const SubString& x, const char* t) 
  1267. {
  1268.   return compare(x, t) <= 0; 
  1269. }
  1270.  
  1271.  
  1272. // a helper needed by at, before, etc.
  1273.  
  1274. inline SubString String::_substr(int first, int l)
  1275. {
  1276.   if (first < 0 || (unsigned)(first + l) > length() )
  1277.     return SubString(_nilString, 0, 0) ;
  1278.   else 
  1279.     return SubString(*this, first, l);
  1280. }
  1281.  
  1282. #endif
  1283.